home *** CD-ROM | disk | FTP | other *** search
/ Amiga Tools 5 / Amiga Tools 5.iso / grafik / converter / limbo4.0 / src / 2d / bitmapio.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-07-16  |  11.0 KB  |  377 lines
  1. #include "includes.h"
  2.  
  3. /**************************************|****************************************
  4. "Routine   : LoadBitMap"
  5. Input  par: char * filename (the name of the file to be loaded)
  6.             int maxx (max xsize)
  7.             int maxy (max ysize)
  8.             int offx (offset x)
  9.             int offy (offset y)
  10.             int BlockSize (the blocksize used)
  11. Output par: Bitmap *SourceImage (the pointer to the bitmap to be encoded)
  12. Global var: none
  13. Function  : Load the bitmap from file filename of the format PGM
  14. ***************************************|***************************************/
  15.  
  16.  BitMap *LoadBitMap(char *file,int maxx,int maxy,int offx,int offy,
  17.                     int BlockSize,char *path)
  18.   {
  19.    BitMap *SourceImage,*TmpImg,*TmpImgR,*TmpImgG,*TmpImgB;
  20.    unsigned int x,y,i,ymax,xmax,type;
  21.    char filename[MAXFILE],temp[MAXSTRING],bitarray[MAXARRAY];
  22.    FILE *in;
  23.    
  24.    vprintf(stderr,"\nLoading BitMap...");
  25.    
  26.    strcpy(filename,path);
  27.    strcat(filename,file);
  28.    
  29.    if (!(in=fopen(filename,"rb"))) /* first try no suffix */
  30.     {
  31.      strcat(filename,PPMSFX);  /* try ppm */
  32.      if (!(in=fopen(filename,"rb")))   
  33.       {
  34.        strcpy(filename,ORGGFX);
  35.        strcat(filename,file);
  36.        strcat(filename,PGMSFX); /* try pgm then */
  37.        if (!(in=fopen(filename,"rb"))) 
  38.         {
  39.          ErrorHandler(NOFILE,file);
  40.          return NULL;
  41.         }
  42.       }
  43.     }
  44.    if (!(fgets(temp,MAXSTRING,in))) 
  45.    ErrorHandler(ERROR_READING,"malformated header in PGM/PPM file");
  46.    
  47.    type=GRAYIMG;
  48.    if (strncmp(temp,PGMMAGIC,2)) 
  49.     {
  50.      if (strncmp(temp,PPMMAGIC,2))
  51.      ErrorHandler(UNKNOWN_GFXFORMAT,"is this a PGM/PPM file?");
  52.      type=RGBIMG;
  53.     }
  54.    
  55.    do
  56.     {
  57.      if (!fgets(temp,MAXSTRING,in)) 
  58.      ErrorHandler(ERROR_READING,"malformated header in PGM/PPM file");
  59.     }
  60.    while(!strncmp(temp,"#",1));
  61.    
  62.    i=0;
  63.    while(strncmp(&(temp[i++])," ",1));
  64.    
  65.    xmax=atoi(temp);
  66.    ymax=atoi(&(temp[i]));
  67.    
  68.    if (!fgets(temp,MAXSTRING,in)) 
  69.    ErrorHandler(ERROR_READING,"malformated header in PGM/PPM file");
  70.    
  71.    if (type==GRAYIMG) vprintf(stderr,"\n   PGM file: '%s'",filename);
  72.    if (type==RGBIMG)  vprintf(stderr,"\n   PPM file: '%s'",filename);
  73.    
  74.    vprintf(stderr,"\n   Size:     (%d,%d)",xmax,ymax);
  75.    
  76.    if (type==GRAYIMG) /* pgm load */
  77.     {
  78.      TmpImg=GimmeABitMap(xmax,ymax,GRAYIMG);  /* allocates memory for SourceImage */
  79.      for(y=0;y<ymax;y++)
  80.       {
  81.        if (!fread(bitarray,xmax,1,in))
  82.        ErrorHandler(ERROR_READING,"malformated body in PGM file");
  83.        for(x=0;x<xmax;x++) TmpImg->Map[x][y] = bitarray[x];
  84.       }
  85.      
  86.      if ((maxx) && (TmpImg->XSize>maxx)) TmpImg->XSize=maxx; /* test for maximum sizes */
  87.      if ((maxy) && (TmpImg->YSize>maxy)) TmpImg->YSize=maxy;
  88.      
  89.      if(TmpImg->XSize%BlockSize) 
  90.      TmpImg->XSize=TmpImg->XSize/BlockSize*BlockSize; /* chop blocksize */
  91.      if(TmpImg->YSize%BlockSize) 
  92.      TmpImg->YSize=TmpImg->YSize/BlockSize*BlockSize;
  93.      
  94.      if((offx+TmpImg->XSize)>xmax) offx=xmax-TmpImg->XSize;
  95.      if((offy+TmpImg->YSize)>ymax) offy=ymax-TmpImg->YSize;
  96.      
  97.      SourceImage=GimmeABitMap(TmpImg->XSize,TmpImg->YSize,GRAYIMG);
  98.      Map2BitMap(TmpImg,SourceImage,offx,offy);
  99.      
  100.      vprintf(stderr,"\n   Truncated:(%d,%d)",TmpImg->XSize,TmpImg->YSize);
  101.      vprintf(stderr,"\n   Offset:   [%d,%d]",offx,offy);
  102.      
  103.      FreeMeABitMap(TmpImg);
  104.     }
  105.    else if (type==RGBIMG) /* ppm load */
  106.     {
  107.      TmpImgR=GimmeABitMap(xmax,ymax,RGBIMG);  /* allocates memory for SourceImage */
  108.      TmpImgG=GimmeABitMap(xmax,ymax,RGBIMG);
  109.      TmpImgB=GimmeABitMap(xmax,ymax,RGBIMG);
  110.      
  111.      for(y=0;y<ymax;y++) 
  112.       {
  113.        if (!fread(bitarray,xmax+xmax+xmax,1,in)) 
  114.        ErrorHandler(ERROR_READING,"malformated body in PGM file");
  115.        for(x=0;x<xmax;x++)  
  116.         {
  117.          register unsigned int dum=3*x;
  118.          TmpImgR->Map[x][y]=bitarray[dum];
  119.          TmpImgG->Map[x][y]=bitarray[dum+1];
  120.          TmpImgB->Map[x][y]=bitarray[dum+2];
  121.         }
  122.       }
  123.      
  124.      if ((maxx) && (TmpImgR->XSize>maxx)) 
  125.       {
  126.        TmpImgR->XSize=maxx;
  127.        TmpImgG->XSize=maxx;
  128.        TmpImgB->XSize=maxx;
  129.       }
  130.      
  131.      if ((maxy) && (TmpImgR->YSize>maxy))
  132.       {
  133.        TmpImgR->YSize=maxy;
  134.        TmpImgG->YSize=maxy;
  135.        TmpImgB->YSize=maxy;
  136.       }
  137.      
  138.      if(TmpImgR->XSize%BlockSize) 
  139.       {
  140.        TmpImgR->XSize=TmpImgR->XSize/BlockSize*BlockSize;
  141.        TmpImgG->XSize=TmpImgG->XSize/BlockSize*BlockSize;
  142.        TmpImgB->XSize=TmpImgB->XSize/BlockSize*BlockSize;
  143.       }
  144.      
  145.      if(TmpImgR->YSize%BlockSize)
  146.       {
  147.        TmpImgR->YSize=TmpImgR->YSize/BlockSize*BlockSize;
  148.        TmpImgG->YSize=TmpImgG->YSize/BlockSize*BlockSize;
  149.        TmpImgB->YSize=TmpImgB->YSize/BlockSize*BlockSize;
  150.       }
  151.      
  152.      if((offx+TmpImgR->XSize)>xmax)
  153.       {
  154.        /* offx=xmax-TmpImgR->XSize;
  155.        offx=xmax-TmpImgG->XSize; */
  156.        offx=xmax-TmpImgB->XSize;
  157.       }
  158.      
  159.      if((offy+TmpImgR->YSize)>ymax)
  160.       {
  161.        /* offy=ymax-TmpImgR->YSize;
  162.        offy=ymax-TmpImgG->YSize; */
  163.        offy=ymax-TmpImgB->YSize;
  164.       }
  165.      
  166.      SourceImage=GimmeABitMap(TmpImgR->XSize,3*TmpImgR->YSize,RGBIMG);
  167.      TmpImg=GimmeABitMap(TmpImgR->XSize,TmpImgR->YSize,RGBIMG);
  168.      
  169.      Map2BitMap(TmpImgR,SourceImage,offx,offy);
  170.      
  171.      Map2BitMap(TmpImgG,TmpImg,offx,offy);
  172.      BitMap2Map(TmpImg,SourceImage,0,TmpImgR->YSize);
  173.      Map2BitMap(TmpImgB,TmpImg,offx,offy);
  174.      BitMap2Map(TmpImg,SourceImage,0,TmpImgR->YSize*2);
  175.      
  176.      vprintf(stderr,"\n   Truncated:(%d,%d)",TmpImg->XSize,TmpImg->YSize);
  177.      vprintf(stderr,"\n   Offset:   [%d,%d]",offx,offy);
  178.      
  179.      FreeMeABitMap(TmpImg);
  180.      FreeMeABitMap(TmpImgR);
  181.      FreeMeABitMap(TmpImgG);
  182.      FreeMeABitMap(TmpImgB);
  183.     }
  184.    else ErrorHandler(UNKNOWN_GFXFORMAT,"Currently no supporting of this format");
  185.    
  186.    SourceImage->ImgType=type;
  187.    
  188.    if (fclose(in)) ErrorHandler(UNABLE_TO_CLOSE,"Unable to close file");
  189.    
  190.    return SourceImage;
  191.   }
  192.  
  193. /**************************************|****************************************
  194.  "Routine   : SaveBitMap"
  195. Input  par: char *filename  (the name of the file to be used)
  196.             Bitmap *DecodeImage (pointer to the decoded image to be saved)
  197. Output par: none
  198. Global par: none
  199. Function  : Save the decoded image in the file filename.
  200. ***************************************|***************************************/
  201.  
  202.  void SaveBitMap(char *file,BitMap *Image,char *path)
  203.   {
  204.    char filename[MAXFILE],bitarray[MAXARRAY];
  205.    unsigned int x,y,ysize;
  206.    char magic[3];
  207.    FILE *out;
  208.    
  209.    strcpy(filename,path);
  210.    strcat(filename,file);
  211.    
  212.    if (Image->ImgType==GRAYIMG)
  213.     {
  214.      strcat(filename,PGMSFX);
  215.      strcpy(magic,PGMMAGIC);
  216.      ysize=Image->YSize;
  217.     }
  218.    else if (Image->ImgType==RGBIMG) 
  219.     {
  220.      strcat(filename,PPMSFX);
  221.      strcpy(magic,PPMMAGIC);
  222.      ysize=Image->YSize/3;
  223.     }
  224.    else ErrorHandler(UNKNOWN_GFXFORMAT,"Not supporting saving of that format");
  225.    
  226.    if (!(out=fopen(filename,"wb"))) 
  227.    ErrorHandler(UNABLE_TO_OPEN,filename);
  228.    fprintf(out,"%s\n# Creator: Limbo version %s\n%d %d\n%d\n",
  229.            magic,LIMBOVERSION,Image->XSize,ysize,255);
  230.    
  231.    if (Image->ImgType==GRAYIMG)
  232.    for(y=0;y<(Image->YSize);y++)
  233.     {
  234.      for(x=0;x<(Image->XSize);x++) bitarray[x] = Image->Map[x][y];
  235.      if (!fwrite(bitarray,Image->XSize,1,out)) 
  236.      ErrorHandler(ERROR_WRITING,"could not write body in PGM file");
  237.     }
  238.    else if (Image->ImgType==RGBIMG)
  239.    for(y=0;y<ysize;y++)
  240.     {
  241.      for(x=0;x<(Image->XSize);x++)
  242.       {
  243.        register unsigned int dum=x*3;
  244.        bitarray[dum]   = Image->Map[x][y];
  245.        bitarray[dum+1] = Image->Map[x][y+ysize];
  246.        bitarray[dum+2] = Image->Map[x][y+ysize*2];
  247.       }
  248.      if (!fwrite(bitarray,Image->XSize*3,1,out))  
  249.      ErrorHandler(ERROR_WRITING,"could not write body in PGM file");
  250.     }
  251.    
  252.    if(fclose(out)) ErrorHandler(UNABLE_TO_CLOSE,"Unable to close PGM file");
  253.   }
  254.  
  255.  
  256.  BitMap3D *LoadBitMap3D(char *file,int maxx,int maxy,int maxz,int offx,
  257.                         int offy,int BlockSize,char *path)
  258.   {
  259.    BitMap3D *SourceImage;
  260.    BitMap  *frame[999];
  261.    char filename[MAXFILE],bitmapsfx[5];
  262.    FILE *in;
  263.    register unsigned int frames=0,i,z;
  264.    char sfx[4];
  265.    int quiet=Quiet;
  266.    
  267.    vprintf(stderr,"\nLoading Sequence...\n   Frames: ");
  268.    
  269.    strcpy(bitmapsfx,"");
  270.    
  271.    strcpy(filename,path);
  272.    strcat(filename,file);
  273.    strcat(filename,".000");
  274.    
  275.    if (!(in=fopen(filename,"rb"))) /* no suffix */
  276.     {
  277.      strcpy(filename,path);
  278.      strcat(filename,file);
  279.      strcat(filename,".000.pgm");
  280.      strcpy(bitmapsfx,".pgm");
  281.      if (!(in=fopen(filename,"rb"))) /* no suffix */
  282.       {
  283.        strcpy(filename,path);
  284.        strcat(filename,file);
  285.        strcat(filename,".000.ppm");
  286.        strcpy(bitmapsfx,".ppm");
  287.        if (!(in=fopen(filename,"rb"))) /* no suffix */ ErrorHandler(UNABLE_TO_OPEN,file);
  288.       }
  289.     }
  290.    
  291.    do
  292.     {
  293.      fclose(in);
  294.      frames++;
  295.      
  296.      strcpy(filename,path);
  297.      strcat(filename,file);
  298.      strcat(filename,".");
  299.      
  300.      sfx[3]='\0';
  301.      sfx[2]=48+(frames-(frames/10)*10);
  302.      sfx[1]=48+(frames/10-(frames/100)*10);
  303.      sfx[0]=48+(frames/100-(frames/1000)*10);
  304.      strncat(filename,sfx,3);
  305.      strcat(filename,bitmapsfx);
  306.      
  307.     }
  308.    while((in=fopen(filename,"rb")) && (frames<maxz || maxz==0));
  309.    
  310.    for(i=0;i<frames;i++)
  311.     {
  312.      Quiet=quiet;
  313.      vprintf(stderr,"[%d]",i);
  314.      
  315.      strcpy(filename,file);
  316.      strcat(filename,".");
  317.      
  318.      sfx[3]='\0';
  319.      sfx[2]=48+(i-(i/10)*10);
  320.      sfx[1]=48+(i/10-(i/100)*10);
  321.      sfx[0]=48+(i/100-(i/1000)*10);
  322.      strncat(filename,sfx,3);
  323.      strcat(filename,bitmapsfx);
  324.      
  325.      Quiet=TRUE;
  326.      frame[i]=LoadBitMap(filename,maxx,maxy,offx,offy,BlockSize,path);
  327.      if (frame[i]->XSize!=frame[0]->XSize ||
  328.          frame[i]->YSize!=frame[0]->YSize ||
  329.          frame[i]->ImgType!=frame[0]->ImgType) 
  330.      ErrorHandler(WRONG_FORMAT,"frames not in the same format");
  331.     }
  332.    Quiet=quiet; /* restore quiet flat */
  333.    
  334.    vprintf(stderr,"\n   Found %d frames of size %d %d",frames,frame[0]->XSize,frame[0]->YSize);
  335.    z=frames;
  336.    if(z%BlockSize) z=z/BlockSize*BlockSize;
  337.    if (z<BlockSize) ErrorHandler(OUT_OF_RANGE,"Too few frames in sequence");
  338.    vprintf(stderr,"\n   Truncated to %d frames of size %d %d",z,frame[0]->XSize,frame[0]->YSize);
  339.    
  340.    SourceImage=GimmeABitMap3D(frame[0]->XSize,frame[0]->YSize,z,frame[0]->ImgType);
  341.    
  342.    for(i=0;i<z;i++) BitMap2Frame(frame[i],SourceImage,i);
  343.    for(i=0;i<frames;i++) FreeMeABitMap(frame[i]);
  344.    
  345.    return SourceImage;
  346.   }
  347.  
  348.  void SaveBitMap3D(char *file,BitMap3D *Seq,char *path)
  349.   {
  350.    BitMap *frame=GimmeABitMap(Seq->XSize,Seq->YSize,Seq->ImgType);
  351.    char filename[MAXFILE];
  352.    register unsigned int z;
  353.    char sfx[4];
  354.    
  355.    vprintf(stderr,"\nSaving Sequence...\n   Frames: ");
  356.    
  357.    for(z=0;z<Seq->ZSize;z++)
  358.     {
  359.      Frame2BitMap(Seq,z,frame);
  360.      
  361.      strcpy(filename,file);
  362.      strcat(filename,".");
  363.      
  364.      sfx[3]='\0';
  365.      sfx[2]=48+(z-(z/10)*10);
  366.      sfx[1]=48+(z/10-(z/100)*10);
  367.      sfx[0]=48+(z/100-(z/1000)*10);
  368.      strncat(filename,sfx,3);
  369.      vprintf(stderr,"[%d]",z);
  370.      
  371.      SaveBitMap(filename,frame,path);
  372.      
  373.     }
  374.    FreeMeABitMap(frame);
  375.    
  376.   }
  377.